home *** CD-ROM | disk | FTP | other *** search
/ Trading on the Edge / Trading On The Edge - CD-ROM Toolkit (Wayzata Technology)(2031)(1994).bin / pc / shared / freeman / jordan.m < prev    next >
Text File  |  1994-01-06  |  14KB  |  281 lines
  1. BeginPackage["Jordan`"]
  2.  
  3. jordan::usage = "jordan[inNumber,hidNumber,outNumber,ioPairs,eta,alpha,mu,numIters]"
  4. jordanTest::usage = "jordanTest[hiddenWts,outputWts,ioPairVectors,
  5.             mu, stateNumber,printAll:False]"
  6. jordan2::usage = "jordan2[inNumber,hidNumber,outNumber,ioPairs,eta,alpha,mu,numIters]"
  7. jordan2Test::usage = "jordan2Test[hiddenWts,outputWts,ioPairVectors,
  8.             mu, stateNumber,printAll:False]"
  9. jordan2a::usage = "jordan2a[inNumber_,hidNumber,outNumber,ioPairs,eta,alpha,mu,numIters]"
  10. jordan2aTanh::usage = "jordan2aTanh[inNumber,hidNumber,outNumber,ioPairs,eta,alpha,mu,numIters]"
  11. jordan2aTanhTest::usage = "jordan2aTanhTest[hiddenWts,outputWts,ioPairVectors,
  12.             mu, stateNumber,printAll:False]"
  13.  
  14.  
  15. Begin["`Private`"]    (* begin the private context *)
  16.  
  17. jordan[inNumber_,hidNumber_,outNumber_,ioPairs_,eta_,alpha_,mu_,numIters_] :=
  18.   Module[{hidWts,outWts,ioP,inputs,hidOuts,outputs,outDesired, 
  19.             i,indx,hidLastDelta,outLastDelta,outDelta,errorList = {}, 
  20.             ioSequence, stateUnits,hidDelta,outErrors},
  21.   hidWts = Table[Table[Random[Real,{-0.5,0.5}],{inNumber+outNumber}],{hidNumber}];
  22.   outWts = Table[Table[Random[Real,{-0.5,0.5}],{hidNumber}],{outNumber}];
  23.   hidLastDelta = Table[Table[0,{inNumber+outNumber}],{hidNumber}];
  24.   outLastDelta = Table[Table[0,{hidNumber}],{outNumber}];
  25.   For[indx=1,indx<=numIters,indx++, (* begin forward pass *)
  26.     ioSequence=ioPairs[[Random[Integer,{1,Length[ioPairs]}]]]; (* select a sequence  *)
  27.     stateUnits = Table[0.1,{outNumber}];   (* reset stateUnits  *)
  28.     For[i=1,i<=Length[ioSequence],i++,     (* process the sequence in order *)
  29.       ioP = ioSequence[[i]];               (* pick out the next ioPair *)
  30.       inputs=Join[stateUnits,ioP[[1]] ];   (* join context and input units *)
  31.       outDesired=ioP[[2]];
  32.       hidOuts = sigmoid[hidWts.inputs];    (* hidden-layer outputs *)
  33.       outputs = sigmoid[outWts.hidOuts];   (* output-layer outputs *)
  34.       outErrors = outDesired-outputs;      (* calculate errors *)
  35.       outDelta= outErrors (outputs (1-outputs));
  36.       hidDelta=(hidOuts (1-hidOuts)) Transpose[outWts].outDelta;
  37.       outLastDelta= eta Outer[Times,outDelta,hidOuts]+alpha outLastDelta;
  38.       outWts += outLastDelta;              (* update weights *)
  39.       hidLastDelta = eta Outer[Times,hidDelta,inputs]+alpha hidLastDelta;
  40.       hidWts += hidLastDelta;              (* update weights *)
  41.       stateUnits = mu stateUnits + outputs; (* update state units *)
  42.          (* put the sum of the squared errors on the list *)
  43.       AppendTo[errorList,outErrors.outErrors];
  44.       ]; (* end of For i *)
  45.   ];     (* end of For indx *)
  46.   Print["New hidden-layer weight matrix: "];
  47.   Print[]; Print[hidWts];Print[];
  48.   Print["New output-layer weight matrix: "];
  49.   Print[]; Print[outWts];Print[];  
  50.   jordanTest[hidWts,outWts,ioPairs,mu,outNumber]; 
  51.   errorPlot = ListPlot[errorList, PlotJoined->True];
  52.   Return[{hidWts,outWts,errorList,errorPlot}];
  53.   ]                        (* end of Module *)
  54.  
  55.  
  56. jordanTest[hiddenWts_,outputWts_,ioPairVectors_,
  57.             mu_, stateNumber_,printAll_:False] :=
  58.   Module[{inputs,hidden,outputs,desired,errors,i,j,
  59.               prntAll,stateUnits,ioSequence,ioP},
  60.     If[printAll,Print[];Print["ioPairs:"];Print[];Print[ioPairVectors]];
  61.        For[i=1,i<=Length[ioPairVectors],i++, (* loop through the sequences  *)
  62.      ioSequence = ioPairVectors[[i]];    (* select the next sequence *)
  63.      stateUnits = Table[0.1,{stateNumber}];  (* reset the context units  *)
  64.          For[j=1,j<=Length[ioSequence],j++,  (* loop through the chosen sequence *)
  65.                ioP = ioSequence[[j]];
  66.                   inputs=Join[stateUnits,ioP[[1]] ];   (* join context and input units *)
  67.                desired=ioP[[2]];
  68.                hidden=sigmoid[hiddenWts.inputs];
  69.                outputs=sigmoid[outputWts.hidden];
  70.                errors= desired-outputs;
  71.                stateUnits = mu stateUnits + outputs; (* update context units *)
  72.                Print[];
  73.                Print["Sequence ",i, " input ",j];
  74.                Print[];Print["inputs:"];Print[];
  75.                Print[inputs];
  76.                If[printAll,Print[];Print["hidden-layer outputs:"];
  77.                    Print[hidden];Print[];  ];
  78.                Print["outputs:"];Print[];
  79.                Print[outputs];Print[];
  80.                Print["desired:"];Print[];Print[desired];Print[];
  81.                Print["Mean squared error:"];
  82.                Print[errors.errors/Length[errors]];
  83.                Print[];
  84.                ];  (* end of For j *)
  85.             ];    (* end of For i *)
  86.     ]                    (* end of Module *)
  87.  
  88.  
  89.  
  90. (* this version sets the state units equal to the desired output values, 
  91. rather than the actual output values, during the training process  *)
  92. jordan2[inNumber_,hidNumber_,outNumber_,ioPairs_,eta_,alpha_,mu_,numIters_] :=
  93.   Module[{hidWts,outWts,ioP,inputs,hidOuts,outputs,outDesired, 
  94.             i,indx,hidLastDelta,outLastDelta,outDelta,errorList = {}, 
  95.             ioSequence, stateUnits,hidDelta,outErrors},
  96.   hidWts = Table[Table[Random[Real,{-0.5,0.5}],{inNumber+outNumber}],{hidNumber}];
  97.   outWts = Table[Table[Random[Real,{-0.5,0.5}],{hidNumber}],{outNumber}];
  98.   hidLastDelta = Table[Table[0,{inNumber+outNumber}],{hidNumber}];
  99.   outLastDelta = Table[Table[0,{hidNumber}],{outNumber}];
  100.   For[indx=1,indx<=numIters,indx++,    (* begin forward pass *)
  101.     ioSequence=ioPairs[[Random[Integer,{1,Length[ioPairs]}]]]; (* select a sequence  *)
  102.     stateUnits = Table[0.1,{outNumber}];   (* reset stateUnits  *)
  103.     For[i=1,i<=Length[ioSequence],i++,     (* process the sequence in order *)
  104.       ioP = ioSequence[[i]];               (* pick out the next ioPair *)
  105.       inputs=Join[stateUnits,ioP[[1]] ];   (* join context and input units *)
  106.       outDesired=ioP[[2]];
  107.       hidOuts = sigmoid[hidWts.inputs];    (* hidden-layer outputs *)
  108.       outputs = sigmoid[outWts.hidOuts];   (* output-layer outputs *)
  109.       outErrors = outDesired-outputs;      (* calculate errors *)
  110.       outDelta= outErrors (outputs (1-outputs));
  111.       hidDelta=(hidOuts (1-hidOuts)) Transpose[outWts].outDelta;
  112.       outLastDelta= eta Outer[Times,outDelta,hidOuts]+alpha outLastDelta;
  113.       outWts += outLastDelta;           (* update weights *)
  114.       hidLastDelta = eta Outer[Times,hidDelta,inputs]+alpha hidLastDelta;
  115.       hidWts += hidLastDelta;           (* update weights *)
  116.       stateUnits = mu stateUnits + outDesired;  (* update state units *)
  117.       AppendTo[errorList,outErrors.outErrors];
  118.       ]; (* end of For i *)
  119.   ];     (* end of For indx *)
  120.   Print["New hidden-layer weight matrix: "];
  121.   Print[]; Print[hidWts];Print[];
  122.   Print["New output-layer weight matrix: "];
  123.   Print[]; Print[outWts];Print[];  
  124.   jordan2Test[hidWts,outWts,ioPairs,mu,outNumber];  
  125.   errorPlot = ListPlot[errorList, PlotJoined->True];
  126.   Return[{hidWts,outWts,errorList,errorPlot}];
  127.   ]                        (* end of Module *)
  128.   
  129.  
  130. jordan2Test[hiddenWts_,outputWts_,ioPairVectors_,
  131.             mu_, stateNumber_,printAll_:False] :=
  132.   Module[{inputs,hidden,outputs,desired,errors,i,j,
  133.               prntAll,stateUnits,ioSequence,ioP},
  134.     If[printAll,Print[];Print["ioPairs:"];Print[];
  135.                      Print[ioPairVectors]];
  136.     For[i=1,i<=Length[ioPairVectors],i++,     (* loop through the sequences  *)
  137.      ioSequence = ioPairVectors[[i]];      (* select the next sequence *)
  138.      stateUnits = Table[0.1,{stateNumber}]; (* reset the context units  *)
  139.          For[j=1,j<=Length[ioSequence],j++,   (* loop through the chosen sequence *)
  140.               ioP = ioSequence[[j]];
  141.               inputs=Join[stateUnits,ioP[[1]] ];    (* join context and input units *)
  142.                desired=ioP[[2]];
  143.                hidden=sigmoid[hiddenWts.inputs];
  144.                outputs=sigmoid[outputWts.hidden];
  145.                errors= desired-outputs;
  146.                stateUnits = mu stateUnits + desired; (* update context units *)
  147.                Print[];
  148.                Print["Sequence ",i, " input ",j];
  149.                Print[];Print["inputs:"];Print[];
  150.                Print[inputs];
  151.                If[printAll,Print[];Print["hidden-layer outputs:"];
  152.                    Print[hidden];Print[];];
  153.                Print["outputs:"];Print[];
  154.                Print[outputs];Print[];
  155.                Print["desired:"];Print[];Print[desired];Print[];
  156.                Print["Mean squared error:"];
  157.                Print[errors.errors/Length[errors]];
  158.                Print[];
  159.                ];  (* end of For j *)
  160.             ];    (* end of For i *)
  161.     ]                    (* end of Module *)
  162.  
  163.  
  164.  
  165. (* this is a modification of jordan2 in which the mean squared error 
  166. is calculated over the entire training pass before being added to the list  *)
  167. jordan2a[inNumber_,hidNumber_,outNumber_,ioPairs_,eta_,alpha_,mu_,numIters_] :=
  168.   Module[{hidWts,outWts,ioP,inputs,hidOuts,outputs,outDesired, 
  169.             i,indx,hidLastDelta,outLastDelta,outDelta,errorList = {},
  170.     cycleError,ioSequence, stateUnits,hidDelta,outErrors},
  171.   hidWts = Table[Table[Random[Real,{-0.5,0.5}],{inNumber+outNumber}],{hidNumber}];
  172.   outWts = Table[Table[Random[Real,{-0.5,0.5}],{hidNumber}],{outNumber}];
  173.   hidLastDelta = Table[Table[0,{inNumber+outNumber}],{hidNumber}];
  174.   outLastDelta = Table[Table[0,{hidNumber}],{outNumber}];
  175.   For[indx=1,indx<=numIters,indx++,       (* begin forward pass *)
  176.     ioSequence=ioPairs[[Random[Integer,{1,Length[ioPairs]}]]];(* select a sequence  *)
  177.     stateUnits = Table[0.1,{outNumber}];      (* reset stateUnits  *)
  178.     cycleError = 0.0;                         (* initialize error  *)
  179.     For[i=1,i<=Length[ioSequence],i++,        (* process the sequence in order *)
  180.       ioP = ioSequence[[i]];                  (* pick out the next ioPair *)
  181.       inputs=Join[stateUnits,ioP[[1]] ];      (* join context and input units *)
  182.       outDesired=ioP[[2]];  
  183.       hidOuts = sigmoid[hidWts.inputs];       (* hidden-layer outputs *)
  184.       outputs = sigmoid[outWts.hidOuts];      (* output-layer outputs *)
  185.       outErrors = outDesired-outputs;         (* calculate errors *)
  186.       outDelta= outErrors (outputs (1-outputs));
  187.       hidDelta=(hidOuts (1-hidOuts)) Transpose[outWts].outDelta;
  188.       outLastDelta= eta Outer[Times,outDelta,hidOuts]+alpha outLastDelta;
  189.       outWts += outLastDelta;                  (* update weights *)
  190.       hidLastDelta = eta Outer[Times,hidDelta,inputs]+alpha hidLastDelta;
  191.       hidWts += hidLastDelta;                  (* update weights *)
  192.       stateUnits = mu stateUnits + outDesired; (* update state units *)
  193.                                                            (* compute mse for this sequence *)
  194.       cycleError=cycleError + outErrors.outErrors/Length[outErrors];
  195.       ]; (* end of For i *)
  196.   AppendTo[errorList,cycleError/Length[ioSequence]];
  197.   ];     (* end of For indx *)
  198.   Print["New hidden-layer weight matrix: "];Print[ ]; Print[hidWts];Print[ ];
  199.   Print["New output-layer weight matrix: "];Print[ ]; Print[outWts];Print[ ];  
  200.   jordan2Test[hidWts,outWts,ioPairs,mu,outNumber]; 
  201.   errorPlot = ListPlot[errorList, PlotJoined->True];
  202.   Return[{hidWts,outWts,errorList,errorPlot}];
  203.   ]                        (* end of Module *)
  204.  
  205.  
  206. (* this is a modification of jordan2a using the Tanh function  *)
  207. jordan2aTanh[inNumber_,hidNumber_,outNumber_,ioPairs_,eta_,alpha_,mu_,numIters_] :=
  208.   Module[{hidWts,outWts,ioP,inputs,hidOuts,outputs,outDesired, 
  209.             i,indx,hidLastDelta,outLastDelta,outDelta,errorList = {}, 
  210.     cycleError,ioSequence, stateUnits,hidDelta,outErrors},
  211.   hidWts = Table[Table[Random[Real,{-0.5,0.5}],{inNumber+outNumber}],{hidNumber}];
  212.   outWts = Table[Table[Random[Real,{-0.5,0.5}],{hidNumber}],{outNumber}];
  213.   hidLastDelta = Table[Table[0,{inNumber+outNumber}],{hidNumber}];
  214.   outLastDelta = Table[Table[0,{hidNumber}],{outNumber}];
  215.   For[indx=1,indx<=numIters,indx++,            (* begin forward pass *)
  216.     ioSequence=ioPairs[[Random[Integer,{1,Length[ioPairs]}]]];(* select a sequence *)
  217.     stateUnits = Table[-0.9,{outNumber}];         (* reset stateUnits  *)
  218.     cycleError = 0.0;                             (* initialize error  *)
  219.     For[i=1,i<=Length[ioSequence],i++,            (* process the sequence in order *)
  220.       ioP = ioSequence[[i]];                      (* pick out the next ioPair *)
  221.       inputs=Join[stateUnits,ioP[[1]] ];          (* join context and input units *)
  222.       outDesired=ioP[[2]];
  223.       hidOuts = Tanh[hidWts.inputs];              (* hidden-layer outputs *)
  224.       outputs = Tanh[outWts.hidOuts];             (* output-layer outputs *)
  225.       outErrors = outDesired-outputs;             (* calculate errors *)
  226.       outDelta= outErrors  (1-outputs^2);
  227.       hidDelta=(1-hidOuts^2) Transpose[outWts].outDelta;
  228.       outLastDelta= eta Outer[Times,outDelta,hidOuts]+alpha outLastDelta;
  229.       outWts += outLastDelta;                     (* update weights *)
  230.       hidLastDelta = eta Outer[Times,hidDelta,inputs]+alpha hidLastDelta;
  231.       hidWts += hidLastDelta;                     (* update weights *)
  232.       stateUnits = mu stateUnits + outDesired;    (* update state units *)
  233.       cycleError=cycleError + outErrors.outErrors/Length[outErrors];
  234.       ]; (* end of For i *)
  235.   AppendTo[errorList,cycleError/Length[ioSequence]];(* put the average mse on the list *)
  236.   ];     (* end of For indx *)
  237.   Print["New hidden-layer weight matrix: "];
  238.   Print[]; Print[hidWts];Print[];
  239.   Print["New output-layer weight matrix: "];
  240.   Print[]; Print[outWts];Print[];  
  241.   jordan2aTanhTest[hidWts,outWts,ioPairs,mu,outNumber]; 
  242.   errorPlot = ListPlot[errorList, PlotJoined->True];
  243.   Return[{hidWts,outWts,errorList,errorPlot}];
  244.   ]                        (* end of Module *)
  245.  
  246.   
  247. jordan2aTanhTest[hiddenWts_,outputWts_,ioPairVectors_,
  248.             mu_, stateNumber_,printAll_:False] :=
  249.   Module[{inputs,hidden,outputs,desired,errors,i,j,
  250.               prntAll,stateUnits,ioSequence,ioP},
  251.     If[printAll,Print[];Print["ioPairs:"];Print[];    Print[ioPairVectors]];
  252.     For[i=1,i<=Length[ioPairVectors],i++,         (* loop through the sequences  *)
  253.      ioSequence = ioPairVectors[[i]];             (* select the next sequence *)
  254.          For[j=1,j<=Length[ioSequence],j++,          (* loop through the chosen sequence *)
  255.               ioP = ioSequence[[j]];
  256.               inputs=Join[stateUnits,ioP[[1]] ];           (* join context and input units *)
  257.                desired=ioP[[2]];
  258.                hidden=Tanh[hiddenWts.inputs];
  259.                outputs=Tanh[outputWts.hidden];
  260.                errors= desired-outputs;
  261.                stateUnits = mu stateUnits + desired;       (* update context units *)
  262.                Print[];
  263.                Print["Sequence ",i, " input ",j];
  264.                Print[];Print["inputs:"];Print[];
  265.                Print[inputs];
  266.                If[printAll,Print[];Print["hidden-layer outputs:"];
  267.                    Print[hidden];Print[];   ];
  268.                Print["outputs:"];Print[];
  269.                Print[outputs];Print[];
  270.                Print["desired:"];Print[];Print[desired];Print[];
  271.                Print["Mean squared error:"];
  272.                Print[errors.errors/Length[errors]];Print[];
  273.                ];  (* end of For j *)
  274.             ];    (* end of For i *)
  275.     ]                    (* end of Module *)
  276.  
  277.  
  278.  
  279. End[]         (* end the private context *)
  280.  
  281. EndPackage[]  (* end the package context *)